diff --git a/user_guide/helpers/array_helper.html b/user_guide/helpers/array_helper.html
index a196214..88e8384 100644
--- a/user_guide/helpers/array_helper.html
+++ b/user_guide/helpers/array_helper.html
@@ -70,8 +70,8 @@
 
 <h2>element()</h2>
 
-<p>Lets you fetch an item from an array.  The function tests whether the array index is set and whether it has a value.  If
-a value exists it is returned.  If a value does not exist it returns FALSE, or whatever you've specified as the default value via the third parameter.  Example:</p>
+<p>Lets you fetch an item from an array. The function tests whether the array index is set and whether it has a value. If
+a value exists it is returned. If a value does not exist it returns FALSE, or whatever you've specified as the default value via the third parameter. Example:</p>
 
 <code>
 $array = array('color' => 'red', 'shape' => 'round', 'size' => '');<br />
@@ -86,7 +86,7 @@
 
 <h2>random_element()</h2>
 
-<p>Takes an array as input and returns a random element from it.  Usage example:</p>
+<p>Takes an array as input and returns a random element from it. Usage example:</p>
 
 <code>$quotes = array(<br />
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"I find that the harder I work, the more luck I seem to have. - Thomas Jefferson",<br />
@@ -102,8 +102,8 @@
 
 <h2>elements()</h2>
 
-<p>Lets you fetch a number of items from an array.  The function tests whether each of the array indices is set.  If an index does not exist
-it is set to FALSE, or whatever you've specified as the default value via the third parameter.  Example:</p>
+<p>Lets you fetch a number of items from an array. The function tests whether each of the array indices is set. If an index does not exist
+it is set to FALSE, or whatever you've specified as the default value via the third parameter. Example:</p>
 
 <code>
 $array = array(<br />
@@ -142,7 +142,7 @@
 );
 </code>
 
-<p>This is useful when sending the <kbd>$_POST</kbd> array to one of your Models.  This prevents users from
+<p>This is useful when sending the <kbd>$_POST</kbd> array to one of your Models. This prevents users from
 sending additional POST data to be entered into your tables:</p>
 
 <code>
diff --git a/user_guide/helpers/captcha_helper.html b/user_guide/helpers/captcha_helper.html
index 2fd5a55..3c6fa11 100644
--- a/user_guide/helpers/captcha_helper.html
+++ b/user_guide/helpers/captcha_helper.html
@@ -83,7 +83,7 @@
 <code>&lt;img src=&quot;http://example.com/captcha/12345.jpg&quot; width=&quot;140&quot; height=&quot;50&quot; /&gt;</code></p>
 
 	<p>The "time" is the micro timestamp used as the image name without the file
-	extension.  It will be a number like this:  1139612155.3422</p>
+	extension. It will be a number like this: 1139612155.3422</p>
 
 	<p>The "word" is the word that appears in the captcha image, which if not
 	supplied to the function, will be a random string.</p>
@@ -109,13 +109,13 @@
 		<li>The captcha function requires the GD image library.</li>
 		<li>Only the img_path and img_url are required.</li>
 		<li>If a "word" is not supplied, the function will generate a random
-		ASCII string.  You might put together your own word library that
+		ASCII string. You might put together your own word library that
 		you can draw randomly from.</li>
 		<li>If you do not specify a path to a TRUE TYPE font, the native ugly GD
 		font will be used.</li>
 		<li>The "captcha" folder must be writable (666, or 777)</li>
 		<li>The "expiration" (in seconds) signifies how long an image will
-		remain in the captcha folder before it will be deleted.  The default
+		remain in the captcha folder before it will be deleted. The default
 		is two hours.</li>
 	</ul>
 
@@ -137,7 +137,7 @@
 &nbsp;KEY `word` (`word`)<br />
 );</code>
 
-	<p>Here is an example of usage with a database.  On the page where the CAPTCHA will be shown you'll have something like this:</p>
+	<p>Here is an example of usage with a database. On the page where the CAPTCHA will be shown you'll have something like this:</p>
 
 <code>$this-&gt;load-&gt;helper(&#x27;captcha&#x27;);<br />
 $vals = array(<br />
diff --git a/user_guide/helpers/cookie_helper.html b/user_guide/helpers/cookie_helper.html
index 34faadb..9879653 100644
--- a/user_guide/helpers/cookie_helper.html
+++ b/user_guide/helpers/cookie_helper.html
@@ -70,20 +70,20 @@
 
 <h2>set_cookie()</h2>
 
-<p>This helper function gives you view file friendly syntax to set browser cookies.  Refer to the <a href="../libraries/input.html">Input class</a> for a description of use, as this function is an alias to $this->input->set_cookie().</p>
+<p>This helper function gives you view file friendly syntax to set browser cookies. Refer to the <a href="../libraries/input.html">Input class</a> for a description of use, as this function is an alias to $this->input->set_cookie().</p>
 
 <h2>get_cookie()</h2>
 
-<p>This helper function gives you view file friendly syntax to get browser cookies.  Refer to the <a href="../libraries/input.html">Input class</a> for a description of use, as this function is an alias to $this->input->cookie().</p>
+<p>This helper function gives you view file friendly syntax to get browser cookies. Refer to the <a href="../libraries/input.html">Input class</a> for a description of use, as this function is an alias to $this->input->cookie().</p>
 
 
 <h2>delete_cookie()</h2>
 
-<p>Lets you delete a cookie.  Unless you've set a custom path or other values, only the name of the cookie is needed:</p>
+<p>Lets you delete a cookie. Unless you've set a custom path or other values, only the name of the cookie is needed:</p>
 
 <code>delete_cookie("name");</code>
 
-<p>This function is otherwise identical to <dfn>set_cookie()</dfn>, except that it does not have the value and expiration parameters.  You can submit an array
+<p>This function is otherwise identical to <dfn>set_cookie()</dfn>, except that it does not have the value and expiration parameters. You can submit an array
 of values in the first parameter or you can set discrete parameters.</p>
 
 <code>delete_cookie($name, $domain, $path, $prefix)</code>
diff --git a/user_guide/helpers/date_helper.html b/user_guide/helpers/date_helper.html
index 44096ff..a293342 100644
--- a/user_guide/helpers/date_helper.html
+++ b/user_guide/helpers/date_helper.html
@@ -72,7 +72,7 @@
 <h2>now()</h2>
 
 <p>Returns the current time as a Unix timestamp, referenced either to your server's local time or GMT, based on the "time reference"
-setting in your config file.  If you do not intend to set your master time reference to GMT (which you'll typically do if you
+setting in your config file. If you do not intend to set your master time reference to GMT (which you'll typically do if you
 run a site that lets each user set their own timezone settings) there is no benefit to using this function over PHP's time() function.
 </p>
 
@@ -82,10 +82,10 @@
 <h2>mdate()</h2>
 
 <p>This function is identical to PHPs <a href="http://www.php.net/date">date()</a> function, except that it lets you
-use MySQL style date codes, where each code letter is preceded with a percent sign:  %Y %m %d etc.</p>
+use MySQL style date codes, where each code letter is preceded with a percent sign: %Y %m %d etc.</p>
 
 <p>The benefit of doing dates this way is that you don't have to worry about escaping any characters that
-are not date codes, as you would normally have to do with the date() function.  Example:</p>
+are not date codes, as you would normally have to do with the date() function. Example:</p>
 
 <code>$datestring = "Year: %Y Month: %m Day: %d - %h:%i %a";<br />
 $time = time();<br />
@@ -149,7 +149,7 @@
 	<tr>
 		<td>DATE_RFC1123</td>
 		<td>RFC 1123</td>
-		<td>Sun, 14 Aug 2005 16:13:03 UTC</td>	
+		<td>Sun, 14 Aug 2005 16:13:03 UTC</td>
 	</tr>
 	<tr>
 		<td>DATE_RFC2822</td>
@@ -170,7 +170,7 @@
 
 <h2>local_to_gmt()</h2>
 
-<p>Takes a Unix timestamp as input and returns it as GMT.  Example:</p>
+<p>Takes a Unix timestamp as input and returns it as GMT. Example:</p>
 
 <code>$now = time();<br />
 <br />
@@ -180,11 +180,11 @@
 <h2>gmt_to_local()</h2>
 
 <p>Takes a Unix timestamp (referenced to GMT) as input, and converts it to a localized timestamp based on the
-timezone and Daylight Saving time submitted.  Example:</p>
+timezone and Daylight Saving time submitted. Example:</p>
 
 <code>
 $timestamp = '1140153693';<br />
-$timezone  = 'UM8';<br />
+$timezone = 'UM8';<br />
 $daylight_saving = TRUE;<br />
 <br />
 echo gmt_to_local($timestamp, $timezone, $daylight_saving);</code>
@@ -208,7 +208,7 @@
 
 <p>This can be useful if you need to display a date in a form field for submission.</p>
 
-<p>The time can be formatted with or without seconds, and it can be set to European or US format.  If only
+<p>The time can be formatted with or without seconds, and it can be set to European or US format. If only
 the timestamp is submitted it will return the time without seconds formatted for the U.S. Examples:</p>
 
 <code>$now = time();<br />
@@ -222,9 +222,9 @@
 
 <h2>human_to_unix()</h2>
 
-<p>The opposite of the above function.  Takes a "human" time as input and returns it as Unix.  This function is
-useful if you accept "human" formatted dates submitted via a form.  Returns FALSE (boolean) if
-the date string passed to it is not formatted as indicated above.  Example:</p>
+<p>The opposite of the above function. Takes a "human" time as input and returns it as Unix. This function is
+useful if you accept "human" formatted dates submitted via a form. Returns FALSE (boolean) if
+the date string passed to it is not formatted as indicated above. Example:</p>
 
 <code>$now = time();<br />
 <br />
@@ -242,9 +242,9 @@
 
 <code>1 Year, 10 Months, 2 Weeks, 5 Days, 10 Hours, 16 Minutes</code>
 
-<p>The first parameter must contain a Unix timestamp.  The second parameter must contain a
-timestamp that is greater that the first timestamp.  If the second parameter empty, the current time will be used.  The most common purpose
-for this function is to show how much time has elapsed from some point in time in the past to now.  Example:</p>
+<p>The first parameter must contain a Unix timestamp. The second parameter must contain a
+timestamp that is greater that the first timestamp. If the second parameter empty, the current time will be used. The most common purpose
+for this function is to show how much time has elapsed from some point in time in the past to now. Example:</p>
 
 <code>$post_date = '1079621429';<br />
 $now = time();<br />
@@ -256,7 +256,7 @@
 
 <h2>days_in_month()</h2>
 
-<p>Returns the number of days in a given month/year. Takes leap years into account.  Example:</p>
+<p>Returns the number of days in a given month/year. Takes leap years into account. Example:</p>
 <code>echo days_in_month(06, 2005);</code>
 
 <p>If the second parameter is empty, the current year will be used.</p>
@@ -304,7 +304,7 @@
 
 <p>This menu is useful if you run a membership site in which your users are allowed to set their local timezone value.</p>
 
-<p>The first parameter lets you set the "selected" state of the menu.  For example, to set Pacific time as the default you will do this:</p>
+<p>The first parameter lets you set the "selected" state of the menu. For example, to set Pacific time as the default you will do this:</p>
 
 <code>echo timezone_menu('UM8');</code>
 
diff --git a/user_guide/helpers/directory_helper.html b/user_guide/helpers/directory_helper.html
index 1a2f28d..2086fe1 100644
--- a/user_guide/helpers/directory_helper.html
+++ b/user_guide/helpers/directory_helper.html
@@ -78,12 +78,12 @@
 
 <p class="important"><strong>Note:</strong> Paths are almost always relative to your main index.php file.</p>
 
-<p>Sub-folders contained within the directory will be mapped as well.  If you wish to control the recursion depth,
+<p>Sub-folders contained within the directory will be mapped as well. If you wish to control the recursion depth,
 you can do so using the second parameter (integer). A depth of 1 will only map the top level directory:</p>
 
 <code>$map = directory_map('./mydirectory/', 1);</code>
 
-<p>By default, hidden files will not be included in the returned array.  To override this behavior,
+<p>By default, hidden files will not be included in the returned array. To override this behavior,
 you may set a third parameter to <var>true</var> (boolean):</p>
 
 <code>$map = directory_map('./mydirectory/', FALSE, TRUE);</code>
diff --git a/user_guide/helpers/file_helper.html b/user_guide/helpers/file_helper.html
index c372354..2d06fa2 100644
--- a/user_guide/helpers/file_helper.html
+++ b/user_guide/helpers/file_helper.html
@@ -69,11 +69,11 @@
 
 <h2>read_file('<var>path</var>')</h2>
 
-<p>Returns the data contained in the file specified in the path.  Example:</p>
+<p>Returns the data contained in the file specified in the path. Example:</p>
 
 <code>$string = read_file('./path/to/file.php');</code>
 
-<p>The path can be a relative or full server path.  Returns FALSE (boolean) on failure.</p>
+<p>The path can be a relative or full server path. Returns FALSE (boolean) on failure.</p>
 
 <p class="important"><strong>Note:</strong> The path is relative to your main site index.php file, NOT your controller or view files.
 CodeIgniter uses a front controller so paths are always relative to the main site index.</p>
@@ -83,7 +83,7 @@
 
 <h2>write_file('<var>path</var>', <kbd>$data</kbd>)</h2>
 
-<p>Writes data to the file specified in the path.  If the file does not exist the function will create it. Example:</p>
+<p>Writes data to the file specified in the path. If the file does not exist the function will create it. Example:</p>
 
 <code>
 $data = 'Some file data';<br />
@@ -101,7 +101,7 @@
 
 <code>write_file('./path/to/file.php', $data, <var>'r+'</var>);</code>
 
-<p>The default mode is <kbd>wb</kbd>.  Please see the <a href="http://php.net/fopen">PHP user guide</a> for mode options.</p>
+<p>The default mode is <kbd>wb</kbd>. Please see the <a href="http://php.net/fopen">PHP user guide</a> for mode options.</p>
 
 <p>Note: In order for this function to write data to a file its file permissions must be set such that it is writable (666, 777, etc.).
 If the file does not already exist, the directory containing it must be writable.</p>
@@ -111,7 +111,7 @@
 
 <h2>delete_files('<var>path</var>')</h2>
 
-<p>Deletes ALL files contained in the supplied path.  Example:</p>
+<p>Deletes ALL files contained in the supplied path. Example:</p>
 <code>delete_files('./path/to/directory/');</code>
 
 <p>If the second parameter is set to <kbd>true</kbd>, any directories contained within the supplied root path will be deleted as well. Example:</p>
@@ -127,12 +127,12 @@
 
 <h2>get_dir_file_info('<var>path/to/directory/</var>', <kbd>$top_level_only</kbd> = TRUE)</h2>
 
-<p>Reads the specified directory and builds an array containing the filenames, filesize, dates, and permissions.  Sub-folders contained within the specified path are only read if forced
+<p>Reads the specified directory and builds an array containing the filenames, filesize, dates, and permissions. Sub-folders contained within the specified path are only read if forced
 	by sending the second parameter, <kbd>$top_level_only</kbd> to <samp>FALSE</samp>, as this can be an intensive operation.</p>
 
 <h2>get_file_info('<var>path/to/file</var>', <kbd>$file_information</kbd>)</h2>
 
-<p>Given a file and path, returns the name, path, size, date modified. Second parameter allows you to explicitly declare what information you want returned; options are: name, server_path, size, date, readable, writable, executable, fileperms.  Returns FALSE if the file cannot be found.</p>
+<p>Given a file and path, returns the name, path, size, date modified. Second parameter allows you to explicitly declare what information you want returned; options are: name, server_path, size, date, readable, writable, executable, fileperms. Returns FALSE if the file cannot be found.</p>
 
 <p class="important"><strong>Note:</strong> The &quot;writable&quot; uses the PHP function is_writable() which is known to have issues on the IIS webserver. Consider using fileperms instead, which returns information from PHP's fileperms() function.</p>
 <h2>get_mime_by_extension('<var>file</var>')</h2>
@@ -142,7 +142,7 @@
 <code>$file = &quot;somefile.png&quot;;<br />
 echo $file . ' is has a mime type of ' . get_mime_by_extension($file);</code>
 </p>
-<p class="critical"><strong>Note:</strong> This is not an accurate way of determining file mime types, and is here strictly as a convenience. It should not be  used for security.</p>
+<p class="critical"><strong>Note:</strong> This is not an accurate way of determining file mime types, and is here strictly as a convenience. It should not be used for security.</p>
 
 <h2>symbolic_permissions(<kbd>$perms</kbd>)</h2>
 
diff --git a/user_guide/helpers/form_helper.html b/user_guide/helpers/form_helper.html
index 87e3c28..b4a5730 100644
--- a/user_guide/helpers/form_helper.html
+++ b/user_guide/helpers/form_helper.html
@@ -72,7 +72,7 @@
 
 <h2>form_open()</h2>
 
-<p>Creates an opening form tag with a base URL <strong>built from your config preferences</strong>.  It will optionally let you
+<p>Creates an opening form tag with a base URL <strong>built from your config preferences</strong>. It will optionally let you
 add form attributes and hidden input fields, and will always add the attribute <kbd>accept-charset</kbd> based on the charset value in your config file.</p>
 
 <p>The main benefit of using this tag rather than hard coding your own HTML is that it permits your site to be more portable
@@ -122,7 +122,7 @@
 
 <h2>form_hidden()</h2>
 
-<p>Lets you generate hidden input fields.  You can either submit a name/value string to create one field:</p>
+<p>Lets you generate hidden input fields. You can either submit a name/value string to create one field:</p>
 
 <code>form_hidden('username', 'johndoe');<br />
 <br />
@@ -149,7 +149,7 @@
 
 <h2>form_input()</h2>
 
-<p>Lets you generate a standard text input field.  You can minimally pass the field name and value in the first
+<p>Lets you generate a standard text input field. You can minimally pass the field name and value in the first
 and second parameter:</p>
 
 <code>echo form_input('username', 'johndoe');</code>
@@ -196,9 +196,9 @@
 
 <h2>form_dropdown()</h2>
 
-<p>Lets you create a standard drop-down field.  The first parameter will contain the name of the field,
+<p>Lets you create a standard drop-down field. The first parameter will contain the name of the field,
 the second parameter will contain an associative array of options, and the third parameter will contain the
-value you wish to be selected.  You can also pass an array of multiple items through the third parameter, and CodeIgniter will create a multiple select for you. Example:</p>
+value you wish to be selected. You can also pass an array of multiple items through the third parameter, and CodeIgniter will create a multiple select for you. Example:</p>
 
 <code>$options = array(<br />
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'small'&nbsp;&nbsp;=> 'Small Shirt',<br />
@@ -215,7 +215,7 @@
 <br />
 &lt;select name=&quot;shirts&quot;&gt;<br />
 &lt;option value=&quot;small&quot;&gt;Small Shirt&lt;/option&gt;<br />
-&lt;option value=&quot;med&quot;&gt;Medium  Shirt&lt;/option&gt;<br />
+&lt;option value=&quot;med&quot;&gt;Medium Shirt&lt;/option&gt;<br />
 &lt;option value=&quot;large&quot; selected=&quot;selected&quot;&gt;Large Shirt&lt;/option&gt;<br />
 &lt;option value=&quot;xlarge&quot;&gt;Extra Large Shirt&lt;/option&gt;<br />
 &lt;/select&gt;<br />
@@ -226,7 +226,7 @@
 <br />
 &lt;select name=&quot;shirts&quot; multiple=&quot;multiple&quot;&gt;<br />
 &lt;option value=&quot;small&quot; selected=&quot;selected&quot;&gt;Small Shirt&lt;/option&gt;<br />
-&lt;option value=&quot;med&quot;&gt;Medium  Shirt&lt;/option&gt;<br />
+&lt;option value=&quot;med&quot;&gt;Medium Shirt&lt;/option&gt;<br />
 &lt;option value=&quot;large&quot; selected=&quot;selected&quot;&gt;Large Shirt&lt;/option&gt;<br />
 &lt;option value=&quot;xlarge&quot;&gt;Extra Large Shirt&lt;/option&gt;<br />
 &lt;/select&gt;</code>
@@ -243,9 +243,9 @@
 
 <h2>form_multiselect()</h2>
 
-<p>Lets you create a standard multiselect field.  The first parameter will contain the name of the field,
+<p>Lets you create a standard multiselect field. The first parameter will contain the name of the field,
 the second parameter will contain an associative array of options, and the third parameter will contain the
-value or values you wish to be selected.  The parameter usage is identical to using <kbd>form_dropdown()</kbd> above,
+value or values you wish to be selected. The parameter usage is identical to using <kbd>form_dropdown()</kbd> above,
 except of course that the name of the field will need to use POST array syntax, e.g. <samp>foo[]</samp>.</p>
 
 
@@ -267,7 +267,7 @@
 &lt;/fieldset&gt;</code>
 <p>Similar to other functions, you can submit an associative array in the second parameter if you prefer to set additional attributes. </p>
 <p><code>$attributes = array('id' =&gt; 'address_info', 'class' =&gt; 'address_info');<br />
-    echo form_fieldset('Address Information', $attributes);<br />
+  echo form_fieldset('Address Information', $attributes);<br />
 echo &quot;&lt;p&gt;fieldset content here&lt;/p&gt;\n&quot;;<br />
 echo form_fieldset_close(); <br />
 <br />
@@ -277,8 +277,8 @@
 &lt;p&gt;form content here&lt;/p&gt; <br />
 &lt;/fieldset&gt;</code></p>
 <h2>form_fieldset_close()</h2>
-<p>Produces a closing &lt;/fieldset&gt; tag.  The only advantage to using this function is it permits you to pass data to it
-    which will be added below the tag.  For example:</p>
+<p>Produces a closing &lt;/fieldset&gt; tag. The only advantage to using this function is it permits you to pass data to it
+  which will be added below the tag. For example:</p>
 <code>$string = &quot;&lt;/div&gt;&lt;/div&gt;&quot;;<br />
 <br />
 echo form_fieldset_close($string);<br />
@@ -309,7 +309,7 @@
 // Would produce:<br /><br />
 &lt;input type="checkbox" name="newsletter" id="newsletter" value="accept" checked="checked" style="margin:10px" /></code>
 
-<p>As with other functions, if you would like the tag to contain  additional data, like JavaScript, you can pass it as a string in the
+<p>As with other functions, if you would like the tag to contain additional data, like JavaScript, you can pass it as a string in the
 fourth parameter:</p>
 
 <code>$js = 'onClick="some_function()"';<br />
@@ -330,7 +330,7 @@
 <br />
 &lt;input type=&quot;submit&quot; name=&quot;mysubmit&quot; value=&quot;Submit Post!&quot; /&gt;</code>
 <p>Similar to other functions, you can submit an associative array in the first parameter if you prefer to set your own attributes.
-    The third parameter lets you add extra data to your form, like JavaScript.</p>
+  The third parameter lets you add extra data to your form, like JavaScript.</p>
 <h2>form_label()</h2>
 <p>Lets you generate a &lt;label&gt;. Simple example:</p>
 <code>echo form_label('What is your Name', 'username');<br />
@@ -338,13 +338,13 @@
 // Would produce:
 <br />
 &lt;label for=&quot;username&quot;&gt;What is your Name&lt;/label&gt;</code>
-<p>Similar to other functions, you can submit an associative array in the third parameter if you prefer to set additional attributes.    </p>
+<p>Similar to other functions, you can submit an associative array in the third parameter if you prefer to set additional attributes.  </p>
 <p><code>$attributes = array(<br />
 &nbsp;&nbsp;&nbsp;&nbsp;'class' =&gt; 'mycustomclass',<br />
 &nbsp;&nbsp;&nbsp;&nbsp;'style' =&gt; 'color: #000;',<br />
 );<br />
-    echo form_label('What is your Name', 'username', $attributes);<br />
-        <br />
+  echo form_label('What is your Name', 'username', $attributes);<br />
+    <br />
 // Would produce: <br />
 &lt;label for=&quot;username&quot; class=&quot;mycustomclass&quot; style=&quot;color: #000;&quot;&gt;What is your Name&lt;/label&gt;</code></p>
 <h2>form_reset()</h2>
@@ -386,8 +386,8 @@
 
 <h2>form_close()</h2>
 
-<p>Produces a closing &lt;/form> tag.  The only advantage to using this function is it permits you to pass data to it
-which will be added below the tag.  For example:</p>
+<p>Produces a closing &lt;/form> tag. The only advantage to using this function is it permits you to pass data to it
+which will be added below the tag. For example:</p>
 
 <code>$string = "&lt;/div>&lt;/div>";<br />
 <br />
@@ -404,7 +404,7 @@
 
 <h2>form_prep()</h2>
 
-<p>Allows you to safely use HTML and characters such as quotes within form elements without breaking out of the form.  Consider this example:</p>
+<p>Allows you to safely use HTML and characters such as quotes within form elements without breaking out of the form. Consider this example:</p>
 
 <code>$string = 'Here is a string containing <strong>"quoted"</strong> text.';<br />
 <br />
@@ -431,7 +431,7 @@
 
 <h2>set_select()</h2>
 
-<p>If you use a <dfn>&lt;select></dfn> menu, this function permits you to display the menu item that was selected.  The first parameter
+<p>If you use a <dfn>&lt;select></dfn> menu, this function permits you to display the menu item that was selected. The first parameter
 must contain the name of the select menu, the second parameter must contain the value of
 each item, and the third (optional) parameter lets you set an item as the default (use boolean TRUE/FALSE).</p>
 
@@ -439,16 +439,16 @@
 
 <code>
 &lt;select name="myselect"><br />
-&lt;option value="one" <dfn>&lt;?php echo  set_select('myselect', 'one', TRUE); ?></dfn> >One&lt;/option><br />
-&lt;option value="two" <dfn>&lt;?php echo  set_select('myselect', 'two'); ?></dfn> >Two&lt;/option><br />
-&lt;option value="three" <dfn>&lt;?php echo  set_select('myselect', 'three'); ?></dfn> >Three&lt;/option><br />
+&lt;option value="one" <dfn>&lt;?php echo set_select('myselect', 'one', TRUE); ?></dfn> >One&lt;/option><br />
+&lt;option value="two" <dfn>&lt;?php echo set_select('myselect', 'two'); ?></dfn> >Two&lt;/option><br />
+&lt;option value="three" <dfn>&lt;?php echo set_select('myselect', 'three'); ?></dfn> >Three&lt;/option><br />
 &lt;/select>
 </code>
 
 
 <h2>set_checkbox()</h2>
 
-<p>Permits you to display a checkbox in the state it was submitted.  The first parameter
+<p>Permits you to display a checkbox in the state it was submitted. The first parameter
 must contain the name of the checkbox, the second parameter must contain its value, and the third (optional) parameter lets you set an item as the default (use boolean TRUE/FALSE). Example:</p>
 
 <code>&lt;input type="checkbox" name="mycheck" value="1" <dfn>&lt;?php echo set_checkbox('mycheck', '1'); ?></dfn> /><br />
@@ -459,8 +459,8 @@
 
 <p>Permits you to display radio buttons in the state they were submitted. This function is identical to the <strong>set_checkbox()</strong> function above.</p>
 
-<code>&lt;input type="radio" name="myradio" value="1" <dfn>&lt;?php echo  set_radio('myradio', '1', TRUE); ?></dfn> /><br />
-&lt;input type="radio" name="myradio" value="2" <dfn>&lt;?php echo  set_radio('myradio', '2'); ?></dfn> /></code>
+<code>&lt;input type="radio" name="myradio" value="1" <dfn>&lt;?php echo set_radio('myradio', '1', TRUE); ?></dfn> /><br />
+&lt;input type="radio" name="myradio" value="2" <dfn>&lt;?php echo set_radio('myradio', '2'); ?></dfn> /></code>
 
 
 
diff --git a/user_guide/helpers/html_helper.html b/user_guide/helpers/html_helper.html
index 308013d..665081f 100644
--- a/user_guide/helpers/html_helper.html
+++ b/user_guide/helpers/html_helper.html
@@ -84,10 +84,10 @@
 <p>The above would produce: &lt;br />&lt;br />&lt;br /></p>
 
 <h2><a name="heading"></a>heading()</h2>
-<p>Lets you create HTML &lt;h1> tags.  The first parameter will contain the data, the
-second the size of the heading.  Example:</p>
+<p>Lets you create HTML &lt;h1> tags. The first parameter will contain the data, the
+second the size of the heading. Example:</p>
 <code>echo heading('Welcome!', 3);</code>
-<p>The above would produce:  &lt;h3>Welcome!&lt;/h3></p>
+<p>The above would produce: &lt;h3>Welcome!&lt;/h3></p>
 
 <p>Additionally, in order to add attributes to the heading tag such as HTML classes, ids or inline styles, a third parameter is available.</p>
 <code>echo heading('Welcome!', 3, 'class="pink"')</code>
@@ -95,7 +95,7 @@
 
 
 <h2><a name="img"></a>img()</h2>
-<p>Lets you create HTML &lt;img /&gt; tags.  The first parameter  contains the image source. Example:</p>
+<p>Lets you create HTML &lt;img /&gt; tags. The first parameter contains the image source. Example:</p>
 <code>echo img('images/picture.jpg');<br />
 // gives &lt;img src=&quot;http://site.com/images/picture.jpg&quot; /&gt;</code>
 <p>There is an optional second parameter that is a TRUE/FALSE value that specifics if the src should have the page specified by $config['index_page'] added to the address it creates. Presumably, this would be if you were using a media controller.</p>
@@ -116,7 +116,7 @@
 	// &lt;img src=&quot;http://site.com/index.php/images/picture.jpg&quot; alt=&quot;Me, demonstrating how to eat 4 slices of pizza at one time&quot; class=&quot;post_images&quot; width=&quot;200&quot; height=&quot;200&quot; title=&quot;That was quite a night&quot; rel=&quot;lightbox&quot; /&gt;</code></p>
 
 <h2><a name="link_tag"></a>link_tag()</h2>
-<p>Lets you create HTML &lt;link /> tags.  This is useful for stylesheet links, as well as other links. The parameters are href, with optional rel, type, title, media and index_page. index_page is a TRUE/FALSE value that specifics if the href should have the page specified by $config['index_page'] added to the address it creates.<code>
+<p>Lets you create HTML &lt;link /> tags. This is useful for stylesheet links, as well as other links. The parameters are href, with optional rel, type, title, media and index_page. index_page is a TRUE/FALSE value that specifics if the href should have the page specified by $config['index_page'] added to the address it creates.<code>
 echo link_tag('css/mystyles.css');<br />
 // gives &lt;link href=&quot;http://site.com/css/mystyles.css&quot; rel=&quot;stylesheet&quot; type=&quot;text/css&quot; /&gt;</code></p>
 <p>Further examples:</p>
@@ -271,20 +271,20 @@
 
 <h2><a name="meta"></a>meta()</h2>
 
-<p>Helps you generate meta tags.  You can pass strings to the function, or simple arrays, or multidimensional ones. Examples:</p>
+<p>Helps you generate meta tags. You can pass strings to the function, or simple arrays, or multidimensional ones. Examples:</p>
 
 <code>
 echo meta('description', 'My Great site');<br />
-// Generates:  &lt;meta name="description" content="My Great Site" /><br />
+// Generates: &lt;meta name="description" content="My Great Site" /><br />
 <br /><br />
 
-echo meta('Content-type', 'text/html; charset=utf-8', 'equiv'); // Note the third parameter.  Can be "equiv" or "name"<br />
-// Generates:  &lt;meta http-equiv="Content-type" content="text/html; charset=utf-8" /><br />
+echo meta('Content-type', 'text/html; charset=utf-8', 'equiv'); // Note the third parameter. Can be "equiv" or "name"<br />
+// Generates: &lt;meta http-equiv="Content-type" content="text/html; charset=utf-8" /><br />
 
 <br /><br />
 
 echo meta(array('name' => 'robots', 'content' => 'no-cache'));<br />
-// Generates:  &lt;meta name="robots" content="no-cache" /><br />
+// Generates: &lt;meta name="robots" content="no-cache" /><br />
 
 <br /><br />
 
@@ -298,7 +298,7 @@
 <br />
 echo meta($meta);
 <br />
-// Generates:  <br />
+// Generates: <br />
 // &lt;meta name="robots" content="no-cache" /><br />
 // &lt;meta name="description" content="My Great Site" /><br />
 // &lt;meta name="keywords" content="love, passion, intrigue, deception" /><br />
@@ -319,7 +319,7 @@
 // &lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"&gt;
 </code>
 
-<p>The following is a list of doctype choices.  These are configurable, and pulled from <samp>application/config/doctypes.php</samp></p>
+<p>The following is a list of doctype choices. These are configurable, and pulled from <samp>application/config/doctypes.php</samp></p>
 
 <table cellpadding="0" cellspacing="1" border="0" style="width:100%" class="tableborder">
 	<tr>
diff --git a/user_guide/helpers/inflector_helper.html b/user_guide/helpers/inflector_helper.html
index 221c059..0876754 100644
--- a/user_guide/helpers/inflector_helper.html
+++ b/user_guide/helpers/inflector_helper.html
@@ -71,7 +71,7 @@
 
 <h2>singular()</h2>
 
-<p>Changes a plural word to singular.  Example:</p>
+<p>Changes a plural word to singular. Example:</p>
 
 <code>
 $word = "dogs";<br />
@@ -81,7 +81,7 @@
 
 <h2>plural()</h2>
 
-<p>Changes a singular word to plural.  Example:</p>
+<p>Changes a singular word to plural. Example:</p>
 
 <code>
 $word = "dog";<br />
@@ -94,7 +94,7 @@
 echo plural($word, TRUE); // Returns &quot;passes&quot; </code>
 
 <h2>camelize()</h2>
-<p>Changes a string of words separated by spaces or underscores to camel case.  Example:</p>
+<p>Changes a string of words separated by spaces or underscores to camel case. Example:</p>
 
 <code>
 $word = "my_dog_spot";<br />
@@ -104,7 +104,7 @@
 
 <h2>underscore()</h2>
 
-<p>Takes multiple words separated by spaces and underscores them.  Example:</p>
+<p>Takes multiple words separated by spaces and underscores them. Example:</p>
 
 <code>
 $word = "my dog spot";<br />
@@ -114,7 +114,7 @@
 
 <h2>humanize()</h2>
 
-<p>Takes multiple words separated by underscores and adds spaces between them.  Each word is capitalized. Example:</p>
+<p>Takes multiple words separated by underscores and adds spaces between them. Each word is capitalized. Example:</p>
 
 <code>
 $word = "my_dog_spot";<br />
diff --git a/user_guide/helpers/language_helper.html b/user_guide/helpers/language_helper.html
index 3b3b87d..e10733b 100644
--- a/user_guide/helpers/language_helper.html
+++ b/user_guide/helpers/language_helper.html
@@ -73,7 +73,7 @@
 
 <p>This function returns a line of text from a loaded language file with simplified syntax
 	that may be more desirable for view files than calling <kbd>$this-&gt;lang-&gt;line()</kbd>.
-	The optional second parameter will also output a form label for you.  Example:</p>
+	The optional second parameter will also output a form label for you. Example:</p>
 
 <code>echo lang('<samp>language_key</samp>', '<samp>form_item_id</samp>');<br />
 // becomes &lt;label for="form_item_id"&gt;language_key&lt;/label&gt;</code>
diff --git a/user_guide/helpers/number_helper.html b/user_guide/helpers/number_helper.html
index 51a4521..a04f37c 100644
--- a/user_guide/helpers/number_helper.html
+++ b/user_guide/helpers/number_helper.html
@@ -71,7 +71,7 @@
 
 <h2>byte_format()</h2>
 
-<p>Formats a numbers as bytes, based on size, and adds the appropriate suffix.  Examples:</p>
+<p>Formats a numbers as bytes, based on size, and adds the appropriate suffix. Examples:</p>
 
 <code>
 echo byte_format(456); // Returns 456 Bytes<br />
diff --git a/user_guide/helpers/security_helper.html b/user_guide/helpers/security_helper.html
index e0cace3..49e0365 100644
--- a/user_guide/helpers/security_helper.html
+++ b/user_guide/helpers/security_helper.html
@@ -71,19 +71,19 @@
 
 <h2>xss_clean()</h2>
 
-<p>Provides Cross Site Script Hack filtering.  This function is an alias to the one in the
-<a href="../libraries/input.html">Input class</a>.  More info can be found there.</p>
+<p>Provides Cross Site Script Hack filtering. This function is an alias to the one in the
+<a href="../libraries/input.html">Input class</a>. More info can be found there.</p>
 
 
 <h2>sanitize_filename()</h2>
 
-<p>Provides protection against directory traversal.  This function is an alias to the one in the
-<a href="../libraries/security.html">Security class</a>.  More info can be found there.</p>
+<p>Provides protection against directory traversal. This function is an alias to the one in the
+<a href="../libraries/security.html">Security class</a>. More info can be found there.</p>
 
 
 <h2>do_hash()</h2>
 
-<p>Permits you to create SHA1 or MD5 one way hashes suitable for encrypting passwords.  Will create SHA1 by default. Examples:</p>
+<p>Permits you to create SHA1 or MD5 one way hashes suitable for encrypting passwords. Will create SHA1 by default. Examples:</p>
 
 <code>
 $str = do_hash($str); // SHA1<br />
@@ -91,13 +91,13 @@
 $str = do_hash($str, 'md5'); // MD5
 </code>
 
-<p class="important"><strong>Note:</strong>  This function was formerly named <kbd>dohash()</kbd>, which has been deprecated in favour of <kbd>do_hash()</kbd>.</p>
+<p class="important"><strong>Note:</strong> This function was formerly named <kbd>dohash()</kbd>, which has been deprecated in favour of <kbd>do_hash()</kbd>.</p>
 
 
 
 <h2>strip_image_tags()</h2>
 
-<p>This is a security function that will strip image tags from a string.  It leaves the image URL as plain text.</p>
+<p>This is a security function that will strip image tags from a string. It leaves the image URL as plain text.</p>
 
 <code>$string = strip_image_tags($string);</code>
 
diff --git a/user_guide/helpers/smiley_helper.html b/user_guide/helpers/smiley_helper.html
index 408df17..4668f10 100644
--- a/user_guide/helpers/smiley_helper.html
+++ b/user_guide/helpers/smiley_helper.html
@@ -83,7 +83,7 @@
 requires that you first download and install the smiley images, then create a controller and the View as described.</p>
 
 <p class="important"><strong>Important:</strong> Before you begin, please <a href="http://codeigniter.com/download_files/smileys.zip">download the smiley images</a> and put them in
-a publicly accessible place on your server.  This helper also assumes you have the smiley replacement array located at
+a publicly accessible place on your server. This helper also assumes you have the smiley replacement array located at
 <dfn>application/config/smileys.php</dfn></p>
 
 
@@ -166,7 +166,7 @@
 
 <h2>get_clickable_smileys()</h2>
 
-<p>Returns an array containing your smiley images wrapped in a clickable link.  You must supply the URL to your smiley folder
+<p>Returns an array containing your smiley images wrapped in a clickable link. You must supply the URL to your smiley folder
 and a field id or field alias.</p>
 
 <code>$image_array = get_smiley_links("http://example.com/images/smileys/", "comment");</code>
@@ -187,10 +187,10 @@
 <h2>parse_smileys()</h2>
 
 <p>Takes a string of text as input and replaces any contained plain text smileys into the image
-equivalent.  The first parameter must contain your string, the second must contain  the URL to your smiley folder:</p>
+equivalent. The first parameter must contain your string, the second must contain the URL to your smiley folder:</p>
 
 <code>
-$str = 'Here are some simileys: :-)  ;-)';
+$str = 'Here are some simileys: :-) ;-)';
 
 $str = parse_smileys($str, "http://example.com/images/smileys/");
 
diff --git a/user_guide/helpers/string_helper.html b/user_guide/helpers/string_helper.html
index 169ee4e..6fc2cf5 100644
--- a/user_guide/helpers/string_helper.html
+++ b/user_guide/helpers/string_helper.html
@@ -70,9 +70,9 @@
 
 <h2>random_string()</h2>
 
-<p>Generates a random string based on the type and length you specify.  Useful for creating passwords or generating random hashes.</p>
+<p>Generates a random string based on the type and length you specify. Useful for creating passwords or generating random hashes.</p>
 
-<p>The first parameter specifies the type of string, the second parameter specifies the length.  The following choices are available:</p>
+<p>The first parameter specifies the type of string, the second parameter specifies the length. The following choices are available:</p>
 
  alpha, alunum, numeric, nozero, unique, md5, encrypt and sha1
 <ul>
@@ -92,7 +92,7 @@
 
 <h2>alternator()</h2>
 
-<p>Allows two or more items to be alternated between, when cycling through a loop.  Example:</p>
+<p>Allows two or more items to be alternated between, when cycling through a loop. Example:</p>
 
 <code>for ($i = 0; $i < 10; $i++)<br />
 {<br />
diff --git a/user_guide/helpers/text_helper.html b/user_guide/helpers/text_helper.html
index f71d878..3c83f3d 100644
--- a/user_guide/helpers/text_helper.html
+++ b/user_guide/helpers/text_helper.html
@@ -71,22 +71,22 @@
 
 <h2>word_limiter()</h2>
 
-<p>Truncates a string to the number of <strong>words</strong> specified.  Example:</p>
+<p>Truncates a string to the number of <strong>words</strong> specified. Example:</p>
 
 <code>
 $string = "Here is a nice text string consisting of eleven words.";<br />
 <br />
 $string = word_limiter($string, 4);<br /><br />
 
-// Returns:  Here is a nice&#8230;
+// Returns: Here is a nice&#8230;
 </code>
 
-<p>The third parameter is an optional suffix added to the string.  By default it adds an ellipsis.</p>
+<p>The third parameter is an optional suffix added to the string. By default it adds an ellipsis.</p>
 
 
 <h2>character_limiter()</h2>
 
-<p>Truncates a string to the number of <strong>characters</strong> specified.  It maintains the integrity
+<p>Truncates a string to the number of <strong>characters</strong> specified. It maintains the integrity
 of words so the character count may be slightly more or less then what you specify. Example:</p>
 
 <code>
@@ -94,7 +94,7 @@
 <br />
 $string = character_limiter($string, 20);<br /><br />
 
-// Returns:  Here is a nice text string&#8230;
+// Returns: Here is a nice text string&#8230;
 </code>
 
 <p>The third parameter is an optional suffix added to the string, if undeclared this helper uses an ellipsis.</p>
@@ -125,9 +125,9 @@
 
 <h2>word_censor()</h2>
 
-<p>Enables you to censor words within a text string.  The first parameter will contain the original string.  The
-second will contain an array of words which you disallow.  The third (optional) parameter can contain a replacement value
-for the words.  If not specified they are replaced with pound signs: ####.  Example:</p>
+<p>Enables you to censor words within a text string. The first parameter will contain the original string. The
+second will contain an array of words which you disallow. The third (optional) parameter can contain a replacement value
+for the words. If not specified they are replaced with pound signs: ####. Example:</p>
 
 <code>
 $disallowed = array('darn', 'shucks', 'golly', 'phooey');<br />
@@ -137,7 +137,7 @@
 
 <h2>highlight_code()</h2>
 
-<p>Colorizes a string of code (PHP, HTML, etc.).  Example:</p>
+<p>Colorizes a string of code (PHP, HTML, etc.). Example:</p>
 
 <code>$string = highlight_code($string);</code>
 
@@ -146,9 +146,9 @@
 
 <h2>highlight_phrase()</h2>
 
-<p>Will highlight a phrase within a text string.  The first parameter will contain the original string, the second will
-contain the phrase you wish to highlight.  The third and fourth parameters will contain the opening/closing HTML tags
-you would like the phrase wrapped in.  Example:</p>
+<p>Will highlight a phrase within a text string. The first parameter will contain the original string, the second will
+contain the phrase you wish to highlight. The third and fourth parameters will contain the opening/closing HTML tags
+you would like the phrase wrapped in. Example:</p>
 
 <code>
 $string = "Here is a nice text string about nothing in particular.";<br />
@@ -164,7 +164,7 @@
 
 <h2>word_wrap()</h2>
 
-<p>Wraps text at the specified <strong>character</strong> count while maintaining complete words.  Example:</p>
+<p>Wraps text at the specified <strong>character</strong> count while maintaining complete words. Example:</p>
 
 <code>$string = "Here is a simple string of text that will help us demonstrate this function.";<br />
 <br />
@@ -180,8 +180,8 @@
 <h2>ellipsize()</h2>
 
 <p>This function will strip tags from a string, split it at a defined maximum length, and insert an ellipsis.</p>
-<p>The first parameter is the string to ellipsize, the second is the number of characters in the final string. The third parameter is where in the string the ellipsis should appear from 0 - 1, left to right.  For example.  a value of 1 will place the ellipsis at the right of the string, .5 in the middle, and 0 at the left.</p>
-<p>An optional forth parameter is the kind of ellipsis.  By default, <samp>&amp;hellip;</samp> will be inserted.</p>
+<p>The first parameter is the string to ellipsize, the second is the number of characters in the final string. The third parameter is where in the string the ellipsis should appear from 0 - 1, left to right. For example. a value of 1 will place the ellipsis at the right of the string, .5 in the middle, and 0 at the left.</p>
+<p>An optional forth parameter is the kind of ellipsis. By default, <samp>&amp;hellip;</samp> will be inserted.</p>
 
 <code>$str = 'this_string_is_entirely_too_long_and_might_break_my_design.jpg';<br />
 <br />
diff --git a/user_guide/helpers/typography_helper.html b/user_guide/helpers/typography_helper.html
index 00686a3..e75528f 100644
--- a/user_guide/helpers/typography_helper.html
+++ b/user_guide/helpers/typography_helper.html
@@ -71,7 +71,7 @@
 
 <h2>auto_typography()</h2>
 
-<p>Formats text so that it is semantically and typographically correct HTML.  Please see the <a href="../libraries/typography.html">Typography Class</a> for more info.</p>
+<p>Formats text so that it is semantically and typographically correct HTML. Please see the <a href="../libraries/typography.html">Typography Class</a> for more info.</p>
 
 <p>Usage example:</p>
 
diff --git a/user_guide/helpers/url_helper.html b/user_guide/helpers/url_helper.html
index d20f1b1..0bcf1e7 100644
--- a/user_guide/helpers/url_helper.html
+++ b/user_guide/helpers/url_helper.html
@@ -69,13 +69,13 @@
 
 <h2>site_url()</h2>
 
-<p>Returns your site URL, as specified in your config file.  The index.php file (or whatever you have set as your
+<p>Returns your site URL, as specified in your config file. The index.php file (or whatever you have set as your
 site <dfn>index_page</dfn> in your config file) will be added to the URL, as will any URI segments you pass to the function.</p>
 
 <p>You are encouraged to use this function any time you need to generate a local URL so that your pages become more portable
 in the event your URL changes.</p>
 
-<p>Segments can be optionally passed to the function as a string or an array.  Here is a string example:</p>
+<p>Segments can be optionally passed to the function as a string or an array. Here is a string example:</p>
 
 <code>echo site_url("news/local/123");</code>
 
@@ -90,7 +90,7 @@
 
 
 <h2>base_url()</h2>
-<p>Returns your site base URL, as specified in your config file.  Example:</p>
+<p>Returns your site base URL, as specified in your config file. Example:</p>
 <code>echo base_url();</code>
 
 
@@ -99,7 +99,7 @@
 
 
 <h2>uri_string()</h2>
-<p>Returns the URI segments of any page that contains this function.  For example, if your URL was this:</p>
+<p>Returns the URI segments of any page that contains this function. For example, if your URL was this:</p>
 <code>http://some-site.com/blog/comments/123</code>
 
 <p>The function would return:</p>
@@ -107,7 +107,7 @@
 
 
 <h2>index_page()</h2>
-<p>Returns your site "index" page, as specified in your config file.  Example:</p>
+<p>Returns your site "index" page, as specified in your config file. Example:</p>
 <code>echo index_page();</code>
 
 
@@ -122,15 +122,15 @@
 
 <code>anchor(<var>uri segments</var>, <var>text</var>, <var>attributes</var>)</code>
 
-<p>The first parameter can contain any segments you wish appended to the URL.  As with the <dfn>site_url()</dfn> function above,
+<p>The first parameter can contain any segments you wish appended to the URL. As with the <dfn>site_url()</dfn> function above,
 segments can be a string or an array.</p>
 
-<p><strong>Note:</strong>&nbsp; If you are building links that are internal to your application do not include the base URL (http://...).  This
+<p><strong>Note:</strong>&nbsp; If you are building links that are internal to your application do not include the base URL (http://...). This
 will be added automatically from the information specified in your config file. Include only the URI segments you wish appended to the URL.</p>
 
-<p>The second segment is the text you would like the link to say.  If you leave it blank, the URL will be used.</p>
+<p>The second segment is the text you would like the link to say. If you leave it blank, the URL will be used.</p>
 
-<p>The third parameter can contain a list of attributes you would like added to the link.  The attributes can be a simple string or an associative array.</p>
+<p>The third parameter can contain a list of attributes you would like added to the link. The attributes can be a simple string or an associative array.</p>
 
 <p>Here are some examples:</p>
 
@@ -148,7 +148,7 @@
 <p>Nearly identical to the <dfn>anchor()</dfn> function except that it opens the URL in a new window.
 
 You can specify JavaScript window attributes in the third parameter to control how the window is opened. If
-the third parameter is not set it will simply open a new window with your own browser settings.  Here is an example
+the third parameter is not set it will simply open a new window with your own browser settings. Here is an example
 with attributes:</p>
 
 <code>
@@ -173,7 +173,7 @@
 
 <h2>mailto()</h2>
 
-<p>Creates a standard HTML email link.  Usage example:</p>
+<p>Creates a standard HTML email link. Usage example:</p>
 
 <code>echo mailto('me@my-site.com', 'Click Here to Contact Me');</code>
 
@@ -188,12 +188,12 @@
 
 <h2>auto_link()</h2>
 
-<p>Automatically turns URLs and email addresses contained in a string into links.  Example:</p>
+<p>Automatically turns URLs and email addresses contained in a string into links. Example:</p>
 
 <code>$string = auto_link($string);</code>
 
-<p>The second parameter determines whether URLs and emails are converted or just one or the other.  Default behavior is both
-if the parameter is not specified.  Email links are encoded as safe_mailto() as shown above.</p>
+<p>The second parameter determines whether URLs and emails are converted or just one or the other. Default behavior is both
+if the parameter is not specified. Email links are encoded as safe_mailto() as shown above.</p>
 
 <p>Converts only URLs:</p>
 <code>$string = auto_link($string, 'url');</code>
@@ -201,42 +201,42 @@
 <p>Converts only Email addresses:</p>
 <code>$string = auto_link($string, 'email');</code>
 
-<p>The third parameter determines whether links are shown in a new window.  The value can be TRUE or FALSE (boolean):</p>
+<p>The third parameter determines whether links are shown in a new window. The value can be TRUE or FALSE (boolean):</p>
 <code>$string = auto_link($string, 'both', TRUE);</code>
 
 
 <h2>url_title()</h2>
 <p>Takes a string as input and creates a human-friendly URL string. This is useful if, for example, you have a blog
-in which you'd like to use the title of your entries in the URL.  Example:</p>
+in which you'd like to use the title of your entries in the URL. Example:</p>
 
 <code>$title = "What's wrong with CSS?";<br />
 <br />
 $url_title = url_title($title);<br />
 <br />
-// Produces:  Whats-wrong-with-CSS
+// Produces: Whats-wrong-with-CSS
 </code>
 
 
-<p>The second parameter determines the word delimiter.  By default dashes are used.  Options are:  <dfn>dash</dfn>, or <dfn>underscore</dfn>:</p>
+<p>The second parameter determines the word delimiter. By default dashes are used. Options are: <dfn>dash</dfn>, or <dfn>underscore</dfn>:</p>
 
 <code>$title = "What's wrong with CSS?";<br />
 <br />
 $url_title = url_title($title, 'underscore');<br />
 <br />
-// Produces:  Whats_wrong_with_CSS
+// Produces: Whats_wrong_with_CSS
 </code>
 
-<p>The third parameter determines whether or not lowercase characters are forced.  By default they are not.  Options are boolean <dfn>TRUE</dfn>/<dfn>FALSE</dfn>:</p>
+<p>The third parameter determines whether or not lowercase characters are forced. By default they are not. Options are boolean <dfn>TRUE</dfn>/<dfn>FALSE</dfn>:</p>
 
 <code>$title = "What's wrong with CSS?";<br />
 <br />
 $url_title = url_title($title, 'underscore', TRUE);<br />
 <br />
-// Produces:  whats_wrong_with_css
+// Produces: whats_wrong_with_css
 </code>
 
 <h3>prep_url()</h3>
-<p>This function will add <kbd>http://</kbd> in the event that a scheme is missing from a URL.  Pass the URL string to the function like this:</p>
+<p>This function will add <kbd>http://</kbd> in the event that a scheme is missing from a URL. Pass the URL string to the function like this:</p>
 <code>
 $url = "example.com";<br /><br />
 $url = prep_url($url);</code>
@@ -250,7 +250,7 @@
 to the controller you want to direct to will create the link. The function will build the URL based on your config file values.</p>
 
 <p>The optional second parameter allows you to choose between the "location"
-method (default) or the "refresh" method.  Location is faster, but on Windows servers it can sometimes be a problem.  The optional third parameter allows you to send a specific HTTP Response Code - this could be used for example to create 301 redirects for search engine purposes. The default Response Code is 302. The third parameter is <em>only</em> available with 'location' redirects, and not 'refresh'. Examples:</p>
+method (default) or the "refresh" method. Location is faster, but on Windows servers it can sometimes be a problem. The optional third parameter allows you to send a specific HTTP Response Code - this could be used for example to create 301 redirects for search engine purposes. The default Response Code is 302. The third parameter is <em>only</em> available with 'location' redirects, and not 'refresh'. Examples:</p>
 
 <code>if ($logged_in == FALSE)<br />
 {<br />
@@ -262,7 +262,7 @@
 
 <p class="important"><strong>Note:</strong> In order for this function to work it must be used before anything is outputted
 to the browser since it utilizes server headers.<br />
-<strong>Note:</strong> For  very fine grained control over headers, you should use the <a href="../libraries/output.html">Output  Library</a>'s set_header() function.</p>
+<strong>Note:</strong> For very fine grained control over headers, you should use the <a href="../libraries/output.html">Output Library</a>'s set_header() function.</p>
 
 
 
diff --git a/user_guide/helpers/xml_helper.html b/user_guide/helpers/xml_helper.html
index ded9aaa..b3d408c 100644
--- a/user_guide/helpers/xml_helper.html
+++ b/user_guide/helpers/xml_helper.html
@@ -78,7 +78,7 @@
 Single and double quotes: ' &nbsp;"<br />
 Dashes: -</p>
 
-<p>This function ignores ampersands if they are part of existing character entities.  Example:</p>
+<p>This function ignores ampersands if they are part of existing character entities. Example:</p>
 
 <code>$string = xml_convert($string);</code>
 
